﻿using System;
using System.ComponentModel;
using System.Reflection;
using System.Runtime.InteropServices;
using Teigha.Core;

namespace Teigha.TD
{
	public class OdDbObjectReactor : OdRxObject
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public OdDbObjectReactor(IntPtr cPtr, bool cMemoryOwn) : base(TD_DbPINVOKE.OdDbObjectReactor_SWIGUpcast(cPtr), cMemoryOwn)
		{
			this.swigCPtr = new HandleRef(this, cPtr);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static HandleRef getCPtr(OdDbObjectReactor obj)
		{
			if (obj != null)
			{
				return obj.swigCPtr;
			}
			return new HandleRef(null, IntPtr.Zero);
		}

		~OdDbObjectReactor()
		{
			this.Dispose();
		}

		public override void Dispose()
		{
			if (this.swigCPtr.Handle != IntPtr.Zero)
			{
				if (this.swigCMemOwn)
				{
					lock (this.locker)
					{
						if (this.swigCPtr.Handle != IntPtr.Zero && this.swigCMemOwn)
						{
							this.swigCMemOwn = false;
							TD_DbPINVOKE.delete_OdDbObjectReactor(this.swigCPtr);
						}
					}
					this.swigCMemOwn = false;
				}
				this.swigCPtr = new HandleRef(null, IntPtr.Zero);
			}
			GC.SuppressFinalize(this);
			base.Dispose();
		}

		public OdDbObjectReactor() : this(TD_DbPINVOKE.new_OdDbObjectReactor(), MemoryManager.GetMemoryManager().GetCurrentTransaction() == null)
		{
			MemoryTransaction currentTransaction = MemoryManager.GetMemoryManager().GetCurrentTransaction();
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectReactor(this.swigCPtr.Handle, true));
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			this.SwigDirectorConnect();
		}

		public new static OdDbObjectReactor cast(OdRxObject pObj)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdDbObjectReactor_cast(OdRxObject.getCPtr(pObj));
			OdDbObjectReactor result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdDbObjectReactor)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdDbObjectReactor)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdDbObjectReactor)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new static OdRxClass desc()
		{
			OdRxClass result = (OdRxClass)Teigha.Core.Helpers.odrxCreateObjectInternal(TD_DbPINVOKE.OdDbObjectReactor_desc(), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdRxClass isA()
		{
			OdRxClass result = (OdRxClass)Teigha.Core.Helpers.odrxCreateObjectInternal(this.SwigDerivedClassHasMethod("isA", OdDbObjectReactor.swigMethodTypes1) ? TD_DbPINVOKE.OdDbObjectReactor_isASwigExplicitOdDbObjectReactor(this.swigCPtr) : TD_DbPINVOKE.OdDbObjectReactor_isA(this.swigCPtr), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdRxObject queryX(OdRxClass protocolClass)
		{
			OdRxObject result = Teigha.Core.Helpers.odrxCreateObjectInternal(this.SwigDerivedClassHasMethod("queryX", OdDbObjectReactor.swigMethodTypes0) ? TD_DbPINVOKE.OdDbObjectReactor_queryXSwigExplicitOdDbObjectReactor(this.swigCPtr, OdRxClass.getCPtr(protocolClass)) : TD_DbPINVOKE.OdDbObjectReactor_queryX(this.swigCPtr, OdRxClass.getCPtr(protocolClass)), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdDbObjectReactor createObject()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdDbObjectReactor_createObject();
			OdDbObjectReactor result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdDbObjectReactor)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdDbObjectReactor)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdDbObjectReactor)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void cancelled(OdDbObject pObject)
		{
			if (this.SwigDerivedClassHasMethod("cancelled", OdDbObjectReactor.swigMethodTypes2))
			{
				TD_DbPINVOKE.OdDbObjectReactor_cancelledSwigExplicitOdDbObjectReactor(this.swigCPtr, OdDbObject.getCPtr(pObject));
			}
			else
			{
				TD_DbPINVOKE.OdDbObjectReactor_cancelled(this.swigCPtr, OdDbObject.getCPtr(pObject));
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void copied(OdDbObject pObject, OdDbObject pNewObject)
		{
			if (this.SwigDerivedClassHasMethod("copied", OdDbObjectReactor.swigMethodTypes3))
			{
				TD_DbPINVOKE.OdDbObjectReactor_copiedSwigExplicitOdDbObjectReactor(this.swigCPtr, OdDbObject.getCPtr(pObject), OdDbObject.getCPtr(pNewObject));
			}
			else
			{
				TD_DbPINVOKE.OdDbObjectReactor_copied(this.swigCPtr, OdDbObject.getCPtr(pObject), OdDbObject.getCPtr(pNewObject));
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void erased(OdDbObject pObject, bool erasing)
		{
			if (this.SwigDerivedClassHasMethod("erased", OdDbObjectReactor.swigMethodTypes4))
			{
				TD_DbPINVOKE.OdDbObjectReactor_erasedSwigExplicitOdDbObjectReactor__SWIG_0(this.swigCPtr, OdDbObject.getCPtr(pObject), erasing);
			}
			else
			{
				TD_DbPINVOKE.OdDbObjectReactor_erased__SWIG_0(this.swigCPtr, OdDbObject.getCPtr(pObject), erasing);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void erased(OdDbObject pObject)
		{
			if (this.SwigDerivedClassHasMethod("erased", OdDbObjectReactor.swigMethodTypes5))
			{
				TD_DbPINVOKE.OdDbObjectReactor_erasedSwigExplicitOdDbObjectReactor__SWIG_1(this.swigCPtr, OdDbObject.getCPtr(pObject));
			}
			else
			{
				TD_DbPINVOKE.OdDbObjectReactor_erased__SWIG_1(this.swigCPtr, OdDbObject.getCPtr(pObject));
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void goodbye(OdDbObject pObject)
		{
			if (this.SwigDerivedClassHasMethod("goodbye", OdDbObjectReactor.swigMethodTypes6))
			{
				TD_DbPINVOKE.OdDbObjectReactor_goodbyeSwigExplicitOdDbObjectReactor(this.swigCPtr, OdDbObject.getCPtr(pObject));
			}
			else
			{
				TD_DbPINVOKE.OdDbObjectReactor_goodbye(this.swigCPtr, OdDbObject.getCPtr(pObject));
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void openedForModify(OdDbObject pObject)
		{
			if (this.SwigDerivedClassHasMethod("openedForModify", OdDbObjectReactor.swigMethodTypes7))
			{
				TD_DbPINVOKE.OdDbObjectReactor_openedForModifySwigExplicitOdDbObjectReactor(this.swigCPtr, OdDbObject.getCPtr(pObject));
			}
			else
			{
				TD_DbPINVOKE.OdDbObjectReactor_openedForModify(this.swigCPtr, OdDbObject.getCPtr(pObject));
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void modified(OdDbObject pObject)
		{
			if (this.SwigDerivedClassHasMethod("modified", OdDbObjectReactor.swigMethodTypes8))
			{
				TD_DbPINVOKE.OdDbObjectReactor_modifiedSwigExplicitOdDbObjectReactor(this.swigCPtr, OdDbObject.getCPtr(pObject));
			}
			else
			{
				TD_DbPINVOKE.OdDbObjectReactor_modified(this.swigCPtr, OdDbObject.getCPtr(pObject));
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void modifiedGraphics(OdDbObject pObject)
		{
			if (this.SwigDerivedClassHasMethod("modifiedGraphics", OdDbObjectReactor.swigMethodTypes9))
			{
				TD_DbPINVOKE.OdDbObjectReactor_modifiedGraphicsSwigExplicitOdDbObjectReactor(this.swigCPtr, OdDbObject.getCPtr(pObject));
			}
			else
			{
				TD_DbPINVOKE.OdDbObjectReactor_modifiedGraphics(this.swigCPtr, OdDbObject.getCPtr(pObject));
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void subObjModified(OdDbObject pObject, OdDbObject pSubObj)
		{
			if (this.SwigDerivedClassHasMethod("subObjModified", OdDbObjectReactor.swigMethodTypes10))
			{
				TD_DbPINVOKE.OdDbObjectReactor_subObjModifiedSwigExplicitOdDbObjectReactor(this.swigCPtr, OdDbObject.getCPtr(pObject), OdDbObject.getCPtr(pSubObj));
			}
			else
			{
				TD_DbPINVOKE.OdDbObjectReactor_subObjModified(this.swigCPtr, OdDbObject.getCPtr(pObject), OdDbObject.getCPtr(pSubObj));
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void modifyUndone(OdDbObject pObject)
		{
			if (this.SwigDerivedClassHasMethod("modifyUndone", OdDbObjectReactor.swigMethodTypes11))
			{
				TD_DbPINVOKE.OdDbObjectReactor_modifyUndoneSwigExplicitOdDbObjectReactor(this.swigCPtr, OdDbObject.getCPtr(pObject));
			}
			else
			{
				TD_DbPINVOKE.OdDbObjectReactor_modifyUndone(this.swigCPtr, OdDbObject.getCPtr(pObject));
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void modifiedXData(OdDbObject pObject)
		{
			if (this.SwigDerivedClassHasMethod("modifiedXData", OdDbObjectReactor.swigMethodTypes12))
			{
				TD_DbPINVOKE.OdDbObjectReactor_modifiedXDataSwigExplicitOdDbObjectReactor(this.swigCPtr, OdDbObject.getCPtr(pObject));
			}
			else
			{
				TD_DbPINVOKE.OdDbObjectReactor_modifiedXData(this.swigCPtr, OdDbObject.getCPtr(pObject));
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void unappended(OdDbObject pObject)
		{
			if (this.SwigDerivedClassHasMethod("unappended", OdDbObjectReactor.swigMethodTypes13))
			{
				TD_DbPINVOKE.OdDbObjectReactor_unappendedSwigExplicitOdDbObjectReactor(this.swigCPtr, OdDbObject.getCPtr(pObject));
			}
			else
			{
				TD_DbPINVOKE.OdDbObjectReactor_unappended(this.swigCPtr, OdDbObject.getCPtr(pObject));
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void reappended(OdDbObject pObject)
		{
			if (this.SwigDerivedClassHasMethod("reappended", OdDbObjectReactor.swigMethodTypes14))
			{
				TD_DbPINVOKE.OdDbObjectReactor_reappendedSwigExplicitOdDbObjectReactor(this.swigCPtr, OdDbObject.getCPtr(pObject));
			}
			else
			{
				TD_DbPINVOKE.OdDbObjectReactor_reappended(this.swigCPtr, OdDbObject.getCPtr(pObject));
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void objectClosed(OdDbObjectId objectId)
		{
			if (this.SwigDerivedClassHasMethod("objectClosed", OdDbObjectReactor.swigMethodTypes15))
			{
				TD_DbPINVOKE.OdDbObjectReactor_objectClosedSwigExplicitOdDbObjectReactor(this.swigCPtr, OdDbObjectId.getCPtr(objectId));
			}
			else
			{
				TD_DbPINVOKE.OdDbObjectReactor_objectClosed(this.swigCPtr, OdDbObjectId.getCPtr(objectId));
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public static OdDbObjectReactor findReactor(OdDbObject pObject, OdRxClass pKeyClass)
		{
			OdDbObjectReactor result = (OdDbObjectReactor)Teigha.Core.Helpers.odrxCreateObjectInternal(TD_DbPINVOKE.OdDbObjectReactor_findReactor(OdDbObject.getCPtr(pObject), OdRxClass.getCPtr(pKeyClass)), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		private void SwigDirectorConnect()
		{
			if (this.SwigDerivedClassHasMethod("queryX", OdDbObjectReactor.swigMethodTypes0))
			{
				this.swigDelegate0 = new OdDbObjectReactor.SwigDelegateOdDbObjectReactor_0(this.SwigDirectorqueryX);
			}
			if (this.SwigDerivedClassHasMethod("isA", OdDbObjectReactor.swigMethodTypes1))
			{
				this.swigDelegate1 = new OdDbObjectReactor.SwigDelegateOdDbObjectReactor_1(this.SwigDirectorisA);
			}
			if (this.SwigDerivedClassHasMethod("cancelled", OdDbObjectReactor.swigMethodTypes2))
			{
				this.swigDelegate2 = new OdDbObjectReactor.SwigDelegateOdDbObjectReactor_2(this.SwigDirectorcancelled);
			}
			if (this.SwigDerivedClassHasMethod("copied", OdDbObjectReactor.swigMethodTypes3))
			{
				this.swigDelegate3 = new OdDbObjectReactor.SwigDelegateOdDbObjectReactor_3(this.SwigDirectorcopied);
			}
			if (this.SwigDerivedClassHasMethod("erased", OdDbObjectReactor.swigMethodTypes4))
			{
				this.swigDelegate4 = new OdDbObjectReactor.SwigDelegateOdDbObjectReactor_4(this.SwigDirectorerased__SWIG_0);
			}
			if (this.SwigDerivedClassHasMethod("erased", OdDbObjectReactor.swigMethodTypes5))
			{
				this.swigDelegate5 = new OdDbObjectReactor.SwigDelegateOdDbObjectReactor_5(this.SwigDirectorerased__SWIG_1);
			}
			if (this.SwigDerivedClassHasMethod("goodbye", OdDbObjectReactor.swigMethodTypes6))
			{
				this.swigDelegate6 = new OdDbObjectReactor.SwigDelegateOdDbObjectReactor_6(this.SwigDirectorgoodbye);
			}
			if (this.SwigDerivedClassHasMethod("openedForModify", OdDbObjectReactor.swigMethodTypes7))
			{
				this.swigDelegate7 = new OdDbObjectReactor.SwigDelegateOdDbObjectReactor_7(this.SwigDirectoropenedForModify);
			}
			if (this.SwigDerivedClassHasMethod("modified", OdDbObjectReactor.swigMethodTypes8))
			{
				this.swigDelegate8 = new OdDbObjectReactor.SwigDelegateOdDbObjectReactor_8(this.SwigDirectormodified);
			}
			if (this.SwigDerivedClassHasMethod("modifiedGraphics", OdDbObjectReactor.swigMethodTypes9))
			{
				this.swigDelegate9 = new OdDbObjectReactor.SwigDelegateOdDbObjectReactor_9(this.SwigDirectormodifiedGraphics);
			}
			if (this.SwigDerivedClassHasMethod("subObjModified", OdDbObjectReactor.swigMethodTypes10))
			{
				this.swigDelegate10 = new OdDbObjectReactor.SwigDelegateOdDbObjectReactor_10(this.SwigDirectorsubObjModified);
			}
			if (this.SwigDerivedClassHasMethod("modifyUndone", OdDbObjectReactor.swigMethodTypes11))
			{
				this.swigDelegate11 = new OdDbObjectReactor.SwigDelegateOdDbObjectReactor_11(this.SwigDirectormodifyUndone);
			}
			if (this.SwigDerivedClassHasMethod("modifiedXData", OdDbObjectReactor.swigMethodTypes12))
			{
				this.swigDelegate12 = new OdDbObjectReactor.SwigDelegateOdDbObjectReactor_12(this.SwigDirectormodifiedXData);
			}
			if (this.SwigDerivedClassHasMethod("unappended", OdDbObjectReactor.swigMethodTypes13))
			{
				this.swigDelegate13 = new OdDbObjectReactor.SwigDelegateOdDbObjectReactor_13(this.SwigDirectorunappended);
			}
			if (this.SwigDerivedClassHasMethod("reappended", OdDbObjectReactor.swigMethodTypes14))
			{
				this.swigDelegate14 = new OdDbObjectReactor.SwigDelegateOdDbObjectReactor_14(this.SwigDirectorreappended);
			}
			if (this.SwigDerivedClassHasMethod("objectClosed", OdDbObjectReactor.swigMethodTypes15))
			{
				this.swigDelegate15 = new OdDbObjectReactor.SwigDelegateOdDbObjectReactor_15(this.SwigDirectorobjectClosed);
			}
			TD_DbPINVOKE.OdDbObjectReactor_director_connect(this.swigCPtr, this.swigDelegate0, this.swigDelegate1, this.swigDelegate2, this.swigDelegate3, this.swigDelegate4, this.swigDelegate5, this.swigDelegate6, this.swigDelegate7, this.swigDelegate8, this.swigDelegate9, this.swigDelegate10, this.swigDelegate11, this.swigDelegate12, this.swigDelegate13, this.swigDelegate14, this.swigDelegate15);
		}

		private bool SwigDerivedClassHasMethod(string methodName, Type[] methodTypes)
		{
			MethodInfo method = base.GetType().GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, methodTypes, null);
			return method.DeclaringType.IsSubclassOf(typeof(OdDbObjectReactor));
		}

		private IntPtr SwigDirectorqueryX(IntPtr protocolClass)
		{
			return OdRxObject.getCPtr(this.queryX((OdRxClass)Teigha.Core.Helpers.odrxCreateObjectInternal(protocolClass, false))).Handle;
		}

		private IntPtr SwigDirectorisA()
		{
			return OdRxClass.getCPtr(this.isA()).Handle;
		}

		private void SwigDirectorcancelled(IntPtr pObject)
		{
			this.cancelled((OdDbObject)Teigha.Core.Helpers.odrxCreateObjectInternal(pObject, false));
		}

		private void SwigDirectorcopied(IntPtr pObject, IntPtr pNewObject)
		{
			this.copied((OdDbObject)Teigha.Core.Helpers.odrxCreateObjectInternal(pObject, false), (OdDbObject)Teigha.Core.Helpers.odrxCreateObjectInternal(pNewObject, false));
		}

		private void SwigDirectorerased__SWIG_0(IntPtr pObject, bool erasing)
		{
			this.erased((OdDbObject)Teigha.Core.Helpers.odrxCreateObjectInternal(pObject, false), erasing);
		}

		private void SwigDirectorerased__SWIG_1(IntPtr pObject)
		{
			this.erased((OdDbObject)Teigha.Core.Helpers.odrxCreateObjectInternal(pObject, false));
		}

		private void SwigDirectorgoodbye(IntPtr pObject)
		{
			this.goodbye((OdDbObject)Teigha.Core.Helpers.odrxCreateObjectInternal(pObject, false));
		}

		private void SwigDirectoropenedForModify(IntPtr pObject)
		{
			this.openedForModify((OdDbObject)Teigha.Core.Helpers.odrxCreateObjectInternal(pObject, false));
		}

		private void SwigDirectormodified(IntPtr pObject)
		{
			this.modified((OdDbObject)Teigha.Core.Helpers.odrxCreateObjectInternal(pObject, false));
		}

		private void SwigDirectormodifiedGraphics(IntPtr pObject)
		{
			this.modifiedGraphics((OdDbObject)Teigha.Core.Helpers.odrxCreateObjectInternal(pObject, false));
		}

		private void SwigDirectorsubObjModified(IntPtr pObject, IntPtr pSubObj)
		{
			this.subObjModified((OdDbObject)Teigha.Core.Helpers.odrxCreateObjectInternal(pObject, false), (OdDbObject)Teigha.Core.Helpers.odrxCreateObjectInternal(pSubObj, false));
		}

		private void SwigDirectormodifyUndone(IntPtr pObject)
		{
			this.modifyUndone((OdDbObject)Teigha.Core.Helpers.odrxCreateObjectInternal(pObject, false));
		}

		private void SwigDirectormodifiedXData(IntPtr pObject)
		{
			this.modifiedXData((OdDbObject)Teigha.Core.Helpers.odrxCreateObjectInternal(pObject, false));
		}

		private void SwigDirectorunappended(IntPtr pObject)
		{
			this.unappended((OdDbObject)Teigha.Core.Helpers.odrxCreateObjectInternal(pObject, false));
		}

		private void SwigDirectorreappended(IntPtr pObject)
		{
			this.reappended((OdDbObject)Teigha.Core.Helpers.odrxCreateObjectInternal(pObject, false));
		}

		private void SwigDirectorobjectClosed(IntPtr objectId)
		{
			this.objectClosed(new OdDbObjectId(objectId, false));
		}

		private object locker = new object();

		private HandleRef swigCPtr;

		private OdDbObjectReactor.SwigDelegateOdDbObjectReactor_0 swigDelegate0;

		private OdDbObjectReactor.SwigDelegateOdDbObjectReactor_1 swigDelegate1;

		private OdDbObjectReactor.SwigDelegateOdDbObjectReactor_2 swigDelegate2;

		private OdDbObjectReactor.SwigDelegateOdDbObjectReactor_3 swigDelegate3;

		private OdDbObjectReactor.SwigDelegateOdDbObjectReactor_4 swigDelegate4;

		private OdDbObjectReactor.SwigDelegateOdDbObjectReactor_5 swigDelegate5;

		private OdDbObjectReactor.SwigDelegateOdDbObjectReactor_6 swigDelegate6;

		private OdDbObjectReactor.SwigDelegateOdDbObjectReactor_7 swigDelegate7;

		private OdDbObjectReactor.SwigDelegateOdDbObjectReactor_8 swigDelegate8;

		private OdDbObjectReactor.SwigDelegateOdDbObjectReactor_9 swigDelegate9;

		private OdDbObjectReactor.SwigDelegateOdDbObjectReactor_10 swigDelegate10;

		private OdDbObjectReactor.SwigDelegateOdDbObjectReactor_11 swigDelegate11;

		private OdDbObjectReactor.SwigDelegateOdDbObjectReactor_12 swigDelegate12;

		private OdDbObjectReactor.SwigDelegateOdDbObjectReactor_13 swigDelegate13;

		private OdDbObjectReactor.SwigDelegateOdDbObjectReactor_14 swigDelegate14;

		private OdDbObjectReactor.SwigDelegateOdDbObjectReactor_15 swigDelegate15;

		private static Type[] swigMethodTypes0 = new Type[]
		{
			typeof(OdRxClass)
		};

		private static Type[] swigMethodTypes1 = new Type[0];

		private static Type[] swigMethodTypes2 = new Type[]
		{
			typeof(OdDbObject)
		};

		private static Type[] swigMethodTypes3 = new Type[]
		{
			typeof(OdDbObject),
			typeof(OdDbObject)
		};

		private static Type[] swigMethodTypes4 = new Type[]
		{
			typeof(OdDbObject),
			typeof(bool)
		};

		private static Type[] swigMethodTypes5 = new Type[]
		{
			typeof(OdDbObject)
		};

		private static Type[] swigMethodTypes6 = new Type[]
		{
			typeof(OdDbObject)
		};

		private static Type[] swigMethodTypes7 = new Type[]
		{
			typeof(OdDbObject)
		};

		private static Type[] swigMethodTypes8 = new Type[]
		{
			typeof(OdDbObject)
		};

		private static Type[] swigMethodTypes9 = new Type[]
		{
			typeof(OdDbObject)
		};

		private static Type[] swigMethodTypes10 = new Type[]
		{
			typeof(OdDbObject),
			typeof(OdDbObject)
		};

		private static Type[] swigMethodTypes11 = new Type[]
		{
			typeof(OdDbObject)
		};

		private static Type[] swigMethodTypes12 = new Type[]
		{
			typeof(OdDbObject)
		};

		private static Type[] swigMethodTypes13 = new Type[]
		{
			typeof(OdDbObject)
		};

		private static Type[] swigMethodTypes14 = new Type[]
		{
			typeof(OdDbObject)
		};

		private static Type[] swigMethodTypes15 = new Type[]
		{
			typeof(OdDbObjectId)
		};

		public delegate IntPtr SwigDelegateOdDbObjectReactor_0(IntPtr protocolClass);

		public delegate IntPtr SwigDelegateOdDbObjectReactor_1();

		public delegate void SwigDelegateOdDbObjectReactor_2(IntPtr pObject);

		public delegate void SwigDelegateOdDbObjectReactor_3(IntPtr pObject, IntPtr pNewObject);

		public delegate void SwigDelegateOdDbObjectReactor_4(IntPtr pObject, bool erasing);

		public delegate void SwigDelegateOdDbObjectReactor_5(IntPtr pObject);

		public delegate void SwigDelegateOdDbObjectReactor_6(IntPtr pObject);

		public delegate void SwigDelegateOdDbObjectReactor_7(IntPtr pObject);

		public delegate void SwigDelegateOdDbObjectReactor_8(IntPtr pObject);

		public delegate void SwigDelegateOdDbObjectReactor_9(IntPtr pObject);

		public delegate void SwigDelegateOdDbObjectReactor_10(IntPtr pObject, IntPtr pSubObj);

		public delegate void SwigDelegateOdDbObjectReactor_11(IntPtr pObject);

		public delegate void SwigDelegateOdDbObjectReactor_12(IntPtr pObject);

		public delegate void SwigDelegateOdDbObjectReactor_13(IntPtr pObject);

		public delegate void SwigDelegateOdDbObjectReactor_14(IntPtr pObject);

		public delegate void SwigDelegateOdDbObjectReactor_15(IntPtr objectId);
	}
}
